package com.gmall.java;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamTest1 {

    // 容器 Array，Collection，容器里面装着对象
    //1、产生流   方式 （4）
    //2、中间操作（可以进行多次操作)  filter，map，limit，sorted
    //3、终止操作(只能执行一次)  forEach，count，max，min，sum，collect

    //Stream 也是一种容器，但是它对对象只能处理一次，不能二次处理，流只能使用一次，用完就没了
    public static void genStream(){
        //数组产生流
        Integer[] array = {1,2,3,4,5};
        Stream<Integer> stream = Arrays.stream(array);

        Arrays.stream(array)//产生流
                .filter(a->a>3)//中间操作
                .forEach(a-> System.out.println(a));//终止操作
        //List 产生流
        List<Integer> list = new ArrayList<>();
        list.add(5);
        list.add(6);
        list.add(10);
        list.add(8);
        list.add(9);

         list.stream()
                 .filter(a->a>8)
                 .forEach(a->{
                     System.out.println(a);
                     System.out.println("-----");
                 });

         //3、Stream.of
         Stream<Integer> stream1 = Stream.of(1,2,3,4,5,11,12,19,12);

        System.out.println("================================");
        stream1
                .filter(a->a>8)
                .forEach(a->{
                    System.out.println(a);
                });
        //4、创建无限流
        Stream<Double> stream2 = Stream.generate(()->{return Math.random()*100;});

        Stream.generate(Math::random);
//        stream2.forEach(a-> System.out.println(a));
        Stream.iterate(1,a->a+1).forEach(a-> System.out.println(a));
    }

    public static void 基本操作(){
        Integer[] array = {1,2,3,4,5};

        Arrays.stream(array)//产生流
                .filter(a->a>3)//中间操作
                .forEach(a-> System.out.println(a));//终止操作
        //结束操作符只能一个，执行结束操作符后Stream就关闭了，不能再使用了
    }

    public static void  中间操作_filter_distinct_sorted_limit_skip(){

        //List 产生流
        List<Integer> list = new ArrayList<>();
        list.add(12);
        list.add(6);
        list.add(10);
        list.add(6);
        list.add(9);
        list.add(16);
        list.add(12);
        list.add(22);

        //1 过滤 filter 方法

        //Comparator 函数式接口
        //compare 方法 (o1,o2) 如果o1>o2 返回正数，如果o1<o2 返回负数，如果o1=o2 返回0
        //2 排序
        //3 distinct 去重
        /*
            6, 9,        10,        12,        16
         */
        list.stream()
                .sorted((o1,o2)->{return o1-o2;})//返回正数 o1在后
                .distinct()
                .limit(4)
                .skip(2)
                .filter(a->a<=20)//Predicate 返回true，接着流，false：过滤掉
                //.forEach(a->System.out.println(a));
                .forEach(System.out::println);//方法引用
    }



    public static void  中间操作_map(){

        Student student1 = new Student("张三", 18);
        Student student2 = new Student("张4", 19);
        Student student3 = new Student("张5", 20);
        Student student4 = new Student("李四", 20);
        Student student5 = new Student("王五", 20);


        List<Student> list = new ArrayList<>();
        list.add(student1);
        list.add(student2);
        list.add(student3);
        list.add(student4);
        list.add(student5);

        List<Double> www = list.stream()
                .filter(a -> a.getAge() > 18)
                .map((s) -> {
                    return "wwww";
                })
                .filter((s) -> {
                    return s.startsWith("www");
                })
                .map((s -> {
                    return 2.3D;
                }))
                .filter((s) -> {
                    return s > 18;
                })
                .collect(Collectors.toList());

        /*List<StudentDTO> huawei = list.stream()
                .filter(a -> a.getAge() > 18)
                .map(student -> {
                    StudentDTO dto = new StudentDTO();
                    dto.setName(student.getName());
                    dto.setAge(student.getAge());
                    dto.setCompany("huawei");
                    return dto;
                }).collect(Collectors.toList());

        System.out.println(huawei);*/
    }
    public static void  中间操作_map_peek() {

        //List 产生流
        List<Integer> list = new ArrayList<>();
        list.add(12);
        list.add(6);
        list.add(10);
        list.add(6);
        list.add(9);
        list.add(16);
        list.add(12);
        list.add(22);

        Stream<Integer> stream = list.stream();


        list.stream()
                .map((a) -> {
                    return new Student("zs",a);
                }).map((a1)->{
                    a1.setAge(a1.getAge()+10);
                    return a1;
                })
                .forEach((a)->{
            System.out.println(a);
        });
    }

    public static void  中间操作_map_reduce() {

        //List 产生流
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(null);
        list.add(null);
        list.add(6);

        Stream<Integer> stream = list.stream();

        Optional<Integer> reduce = list.stream()
                .map((a) -> {
                    return a!=null?1:0;
                }).reduce((a, b) -> {
                    return a + b;
                });

        if(reduce.isPresent()){
            System.out.println(reduce.get());
        }
    }

    public static void  结束操作_collect(){

        //List 产生流
        List<Integer> list = new ArrayList<>();
        list.add(12);
        list.add(6);
        list.add(10);
        list.add(6);
        list.add(9);
        list.add(16);

        List<Integer> collect = list.stream()
                .filter(a -> a <= 10)
                .collect(Collectors.toList());

        collect.forEach((a) -> {
            System.out.println("key:" + a);
        });
    }

    public static void  结束操作_count_max_min(){

        //List 产生流
        List<Integer> list = new ArrayList<>();
        list.add(12);
        list.add(6);
        list.add(10);
        list.add(6);
        list.add(9);
        list.add(16);

        Optional<Integer> max = list.stream()
                .filter(a -> a <= 10)
                .max((o1, o2) -> {
                    return o2 - o1;
                });

        if(max.isPresent()){
            Integer i = max.get();
            System.out.println(i);
        }
    }

    public static void  结束操作_find(){

        //List 产生流
        List<Integer> list = new ArrayList<>();
        list.add(12);
        list.add(6);
        list.add(10);
        list.add(6);
        list.add(9);
        list.add(16);

        boolean b = list.stream()
                .anyMatch(a -> a <= 10);

        System.out.println(b);
    }


    public static void main(String[] args) {
        中间操作_map();
    }

}

